package com.jiepos.mpos.core.util;

import java.math.BigDecimal;
import java.math.BigInteger;
/**
 * 
 * <p>标题: —— 数据操作工具类</p>
 * <p>模块: 通用平台</p>
 * <p>版权: Copyright (c) 2017 江苏杰博实信息技术有限公司
 * @author 娄伟峰
 * @version 1.0
 * @since 2017年9月11日 下午1:51:41
 * @history（历次修订内容、修订人、修订时间等）
 */
public class MathUtils {
 
 // 默认除法运算精度
 	private static final int DEF_DIV_SCALE = 10;

 	/**
 	 * 用dividend/divisor 对结果进行向上取整 如果dividend divisor 有一个为空字符串返回0 roundCeil <br>
 	 * 
 	 * @param dividend
 	 *            被除数
 	 * @param divisor
 	 *            除数
 	 * @return long
 	 */
 	public static long roundCeil(String dividend, String divisor) {
 		dividend = StringUtils.trimNumber(dividend);
 		divisor = StringUtils.trimNumber(divisor);
 		BigDecimal total = new BigDecimal(dividend);
 		BigDecimal per = new BigDecimal(divisor);
 		return total.divide(per, BigDecimal.ROUND_CEILING).longValue();
 	}

 	/**
 	 * 用dividend/divisor 对结果进行向上取整 如果dividend divisor 有一个为空字符串返回0 roundCeil <br>
 	 * 
 	 * @param dividend
 	 *            被除数
 	 * @param divisor
 	 *            除数
 	 * @return long
 	 */
 	public static long roundCeil(BigDecimal dividend, BigDecimal divisor) {
 		return dividend.divide(divisor, BigDecimal.ROUND_CEILING).longValue();
 	}

 	/**
 	 * 用dividend/divisor 对结果进行向下取整 roundFloor <br>
 	 * 
 	 * @param dividend
 	 *            被除数
 	 * @param divisor
 	 *            除数
 	 * @return long
 	 */
 	public static long roundFloor(String dividend, String divisor) {
 		dividend = StringUtils.trimNumber(dividend);
 		divisor = StringUtils.trimNumber(divisor);
 		BigDecimal total = new BigDecimal(dividend);
 		BigDecimal per = new BigDecimal(divisor);
 		return total.divide(per, BigDecimal.ROUND_FLOOR).longValue();
 	}

 	/**
 	 * 用dividend/divisor 对结果进行向下取整 roundFloor <br>
 	 * 
 	 * @param dividend
 	 *            被除数
 	 * @param divisor
 	 *            除数
 	 * @return long
 	 */
 	public static long roundFloor(BigDecimal dividend, BigDecimal divisor) {
 		return dividend.divide(divisor, BigDecimal.ROUND_FLOOR).longValue();
 	}

 	/**
 	 * 计算基数radix的指数exponent次乘幂 powInteger <br>
 	 * 
 	 * @param radix
 	 *            基数
 	 * @param exponent
 	 *            指数
 	 * @return long
 	 */
 	public static long powInteger(BigInteger radix, int exponent) {
 		return radix.pow(exponent).longValue();
 	}

 	/**
 	 * 计算以10为基数的指数exponent次乘幂 powInteger <br>
 	 * 
 	 * @param exponent
 	 *            指数
 	 * @return long exponent
 	 */
 	public static long tenPowInteger(int exponent) {
 		BigInteger radix = new BigInteger("10");
 		return radix.pow(exponent).longValue();
 	}

 	/**
 	 * 提供精确的加法运算。
 	 * 
 	 * @param v1
 	 *            被加数
 	 * @param v2
 	 *            加数
 	 * @return 两个参数的和
 	 */

 	public static double add(double v1, double v2) {
 		BigDecimal b1 = new BigDecimal(Double.toString(v1));
 		BigDecimal b2 = new BigDecimal(Double.toString(v2));
 		return b1.add(b2).doubleValue();
 	}

 	/**
 	 * 提供精确的减法运算。
 	 * 
 	 * @param v1
 	 *            被减数
 	 * @param v2
 	 *            减数
 	 * @return 两个参数的差
 	 */

 	public static double sub(double v1, double v2) {
 		BigDecimal b1 = new BigDecimal(Double.toString(v1));
 		BigDecimal b2 = new BigDecimal(Double.toString(v2));
 		return b1.subtract(b2).doubleValue();
 	}

 	/**
 	 * 提供精确的乘法运算。
 	 * 
 	 * @param v1
 	 *            被乘数
 	 * @param v2
 	 *            乘数
 	 * @return 两个参数的积
 	 */

 	public static double mul(double v1, double v2) {
 		BigDecimal b1 = new BigDecimal(Double.toString(v1));
 		BigDecimal b2 = new BigDecimal(Double.toString(v2));
 		return b1.multiply(b2).doubleValue();
 	}

 	/**
 	 * 提供（相对）精确的除法运算，当发生除不尽的情况时，精确到 小数点以后10位，以后的数字四舍五入。
 	 * 
 	 * @param v1
 	 *            被除数
 	 * @param v2
 	 *            除数
 	 * @return 两个参数的商
 	 */

 	public static double div(double v1, double v2) {
 		return div(v1, v2, DEF_DIV_SCALE);
 	}

 	/**
 	 * 提供（相对）精确的除法运算。当发生除不尽的情况时，由scale参数指 定精度，以后的数字四舍五入。
 	 * 
 	 * @param v1
 	 *            被除数
 	 * @param v2
 	 *            除数
 	 * @param scale
 	 *            表示表示需要精确到小数点以后几位。
 	 * @return 两个参数的商
 	 */

 	public static double div(double v1, double v2, int scale) {
 		if (scale < 0) {
 			throw new IllegalArgumentException(
 					"The   scale   must   be   a   positive   integer   or   zero");
 		}
 		BigDecimal b1 = new BigDecimal(Double.toString(v1));
 		BigDecimal b2 = new BigDecimal(Double.toString(v2));
 		return b1.divide(b2, scale, BigDecimal.ROUND_HALF_UP).doubleValue();
 	}

 	/**
 	 * 提供精确的小数位四舍五入处理。
 	 * @param v 需要四舍五入的数字
 	 * @param scale 小数点后保留几位
 	 * @return double 四舍五入后的结果
 	 */
 	public static double round(double v, int scale) {
 		if (scale < 0) {
 			throw new IllegalArgumentException(
 					"The   scale   must   be   a   positive   integer   or   zero");
 		}
 		BigDecimal b = new BigDecimal(Double.toString(v));
 		BigDecimal one = new BigDecimal("1");
 		return b.divide(one, scale, BigDecimal.ROUND_HALF_UP).doubleValue();
 	}

 	public static void main(String args[]) {
/* 		String dividend = "10";
 		String divisor = "3";
 		System.out.println("=====1==" + roundCeil(dividend, divisor));
 		System.out.println("=====2==" + roundFloor(dividend, divisor));*/
 		System.out.println(1000%1000);
 	}
}
